/*
 * All rights Reserved, Designed By cloudland Copyright(C) 2010-2014
 *
 * fileName:  DocumentDescImpl.java
 * author:  lei
 * Company:  Cloudland Studio
 * Createdate:  2013-9-19 下午10:02:42
 *   
 * Modification  History:
 *     Date           Author        Version        
 * -------------------------------------------
 * 2013-9-19          Lei            1.0        
 *
 * Why & What is modified:
 * 1.0: 文件创建
 */
package org.cloudland.search.config.support;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;

import org.apache.log4j.Logger;
import org.apache.lucene.analysis.Analyzer;
import org.cloudland.search.config.IDocumentDesc;
import org.cloudland.search.config.IFieldDesc;
import org.cloudland.search.exception.ConstantsException;
import org.cloudland.search.exception.SearchException;

 /**
 * <pre> 
 * 获取搜索配置文件中对搜索相关限制的配置，
 * 如：索引文件存放位置，使用的分词器实现类等。实现了IDocumentDesc接口
 * </pre>
 * @ClassName  DocumentDescImpl
 * @author  lei
 * @version  %I%, %G%
 * @see  
 * @since   JDK1.6
 *
 */
public class DocumentDescImpl implements IDocumentDesc {

private Logger logger = Logger.getLogger(DocumentDescImpl.class);
    
    private DocumentDescEntity documentDescEntity;
    
    public DocumentDescImpl()
    {
        
    }
    
    /**
     * 
     *@description: 设置文档描述对象
     *@param documentDescEntity
     */
    public void setDocumentDescEntity(DocumentDescEntity documentDescEntity)
    {
        this.documentDescEntity = documentDescEntity;
    }
    
    /**
     * 
     *@description: 获取配置的分词实现对象
     *@return 分词对象
     */
    public Analyzer getSearchAnalyzer()
    {
        Analyzer result = null;
        
        if (documentDescEntity != null)
        {
            result = documentDescEntity.getSearchAnalyzer();
          
        }//end if
        else
        {
            logger.warn("数据源对象documentDescEntity为空，无法获取分词实现对象对应数据");
        }
        
        
        return result;
    }
    
    /**
     * 
     *@description: 获取索引文件的存储路径
     *@return 索引文件的存储路径对象
     */
    public File getIndexPosition()
    {
        File result = null;
        
        if (documentDescEntity != null)
        {
            result = documentDescEntity.getIndexPosition();
        }
        else
        {
            logger.warn("数据源对象documentDescEntity为空，无法获取索引文件的存储路径对应数据");
        }
        
        return result;
    }
    
    /**
     * 
     *@description: 获取配置的索引域描述
     *@return 索引域描述数组
     */
    public IFieldDesc[] getFieldDesc()
    {
        IFieldDesc[] result = null;
        
        if (documentDescEntity != null)
        {
            List<FieldDescEntity> fieldList =  documentDescEntity.getFieldDescList();
            if (fieldList!=null && fieldList.size()>0)
            {
                result = new IFieldDesc[fieldList.size()];
                FieldDescImpl tempEntity = null;
                
                for (int i=0; i<fieldList.size(); i++)
                {
                    tempEntity = new FieldDescImpl();
                    tempEntity.setFieldDescEntity(fieldList.get(i));
                    result[i] = tempEntity;
                }//end for
            }
            else
            {
                logger.warn("获取配置的索引域描述没有取得数据，无法对外提供接口数据");
            }
            
        }//end if
        else
        {
            logger.warn("数据源对象documentDescEntity为空，无法获取对应数据");
        }
        
        return result;
    }
    
    /**
     * 
     *@description: 获取索引配置服务的名称，不同平台配置使用不同的服务名称
     *@return 配置服务的名称
     */
    public String getSearchName()
    {
        String result = null;
        
        if (documentDescEntity != null)
        {
            result = documentDescEntity.getSearchName();
        }
        else
        {
            logger.warn("数据源对象documentDescEntity为空，无法获取对应数据");
        }
        
        return result;
    }
    
    
    
    /**
     * 
     * 
     * @ClassName FieldDescEntity 
     * @Description 索引域的信息存放实体
     * @author jinqiang
     * @date 2013-8-28 下午3:09:44
     * @version 1.0
     *
     */
    public class DocumentDescEntity
    {
        private Analyzer searchAnalyzer;//使用的分词器实现类路径
        
        private File indexPosition;//索引文件的存储位置
        
        private String searchName;//搜索的服务平台名称
        
        private List<FieldDescEntity> fieldDescList = new ArrayList<FieldDescEntity>();//索引域描述
        
        private List<ConstructorParameter> parameterList = new ArrayList<ConstructorParameter>();//构造函数参数列表
        
        /**
         * 获取使用的分词器实现类路径
         * @return searchAnalyzer 使用的分词器实现类路径
         */
        public Analyzer getSearchAnalyzer()
        {
            return searchAnalyzer;
        }

        /**
         * 设置使用的分词器实现类路径
         * @param 使用的分词器实现类路径
         */
        public void setSearchAnalyzer(String searchAnalyzer)
        {
            Analyzer result = null;
            
                try
                {
                    Class<?> analyzerClass = Class.forName(searchAnalyzer);
                    Class<?>[] parameterTypeArray = null;
                    Object[] parameterArray = null;
                    
                    if (parameterList!=null && parameterList.size()>0)
                    {
                        parameterTypeArray = new Class<?>[parameterList.size()];
                        parameterArray = new Object[parameterList.size()];
                        for (int i=0; i<parameterList.size(); i++)
                        {
                            parameterTypeArray[i]=parameterList.get(i).getParameterType();
                            parameterArray[i]=parameterList.get(i).getParameterValue();
                        }
                    }
                    
                    Constructor<?> constructor= analyzerClass.getConstructor(parameterTypeArray);
                    result = (Analyzer) constructor.newInstance(parameterArray);
              
                }
                catch (ClassNotFoundException e)
                {
                    logger.error("没有找到搜索使用的分词类["+searchAnalyzer+"]", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0003);
                }
                catch (InstantiationException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]实例化失败", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0004);
                }
                catch (IllegalAccessException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]非法访问异常", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0005);
                }
                catch (IllegalArgumentException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]实例化失败", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0004);
                }
                catch (InvocationTargetException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]实例化失败", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0004);
                }
                catch (SecurityException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]实例化失败", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0004);
                }
                catch (NoSuchMethodException e)
                {
                    logger.error("搜索使用的分词类["+searchAnalyzer+"]实例化失败", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0004);
                }
            
            
            this.searchAnalyzer = result;
        }

        /**
         * 获取索引文件的存储位置
         * @return indexPosition 索引文件的存储位置
         */
        public File getIndexPosition()
        {
            return indexPosition;
        }

        /**
         * 设置索引文件的存储位置
         * @param 索引文件的存储位置
         */
        public void setIndexPosition(String indexPosition)
        {
            File indexFile = null;

                try
                {
                    indexFile = new File(indexPosition);
                }
                catch (Exception e)
                {
                    logger.error("获取搜索索引位置的文件对象产生错误", e);
                    throw new SearchException(ConstantsException.SEARCH_CONFIG_0006);
                }
         
            this.indexPosition = indexFile;
        }

        /**
         * 获取索引域描述
         * @return fieldDescList 索引域描述
         */
        public List<FieldDescEntity> getFieldDescList()
        {
            return fieldDescList;
        }

        /**
         * 设置索引域描述
         * @param 索引域描述
         */
        public void setFieldDescList(List<FieldDescEntity> fieldDescList)
        {
            this.fieldDescList = fieldDescList;
        }

        /**
         * 获取搜索的服务平台名称
         * @return searchName 搜索的服务平台名称
         */
        public String getSearchName()
        {
            return searchName;
        }

        /**
         * 设置搜索的服务平台名称
         * @param 搜索的服务平台名称
         */
        public void setSearchName(String searchName)
        {
            this.searchName = searchName;
        }

        /**
         * 获取构造函数参数列表
         * @return parameterList 构造函数参数列表
         */
        public List<ConstructorParameter> getParameterList()
        {
            return parameterList;
        }

        /**
         * 设置构造函数参数列表
         * @param 构造函数参数列表
         */
        public void setParameterList(List<ConstructorParameter> parameterList)
        {
            this.parameterList = parameterList;
        }
        
    }

}
